Electronic systems, such as, computerized devices or computer controlled apparatus, are employed in dramatic numbers to perform various operations in diverse applications. These electronic systems range in complexity from simple consumer products, such as, home appliances and children's toys to complex arrangements, such as, aircraft autopilot systems, chemical processing controls or safety devices for complicated applications. Many of these electronic systems rely on internal, or embedded, computers for at least a portion of their functionality.
Such embedded computer systems often carry out such operations as sensing, computation, display, and control in response to stimuli from internal and external sources. Certain sensing and control applications have demanding speed requirements which can be described as "real time" speed requirements. Real time speed requirements demand that the embedded computer system responded to events or stimuli within a strict, specified amount of time. For example, embedded computer systems are utilized in most modern automobiles to control tasks, such as, fuel injection, anti-lock braking, air bag deployment, engine ignition, anti-lock braking, air bag deployment, engine ignition and other operations.
The amount of time allowed for computer response is generally very small. For example, an embedded computer system must rapidly analyze deceleration data to accurately and appropriately deploy an air bag in an automobile. This ability to meet stringent timing requirements often requires that processing resources be available upon demand in a predictable amount of time. Consequently, real-time computer systems typically utilize specialized and complex software to meet real time speed requirements. Many prior art real-time systems have been programmed in relatively "low-level" languages, such as assembly language, so that the programmer can maintain the strict control over the system operation which is necessary to meet the strict time requirements.
A significant consideration in the performance and effectiveness if a real-time computer system is the programming language methodology that is used to create and maintain the software elements that ultimately determine the functionality of the embedded computer system. With present day hardware fabrication costs, the software development costs often far outweigh the hardware costs. Consequently, it would be advantageous to reduce software development and maintenance costs. One problem with programs written in low-level languages is that they are often costly to develop and difficult to maintain.
A wide range of programming methods and languages have historically been used to develop the software elements or programs. The programming methods have ranged from the previously-discussed low level machine specific assembly languages to high level languages which are not specific to a particular hardware element or platform. Generally, high level languages are more efficient in both the design and maintenance of software programs so that their use is particularly advantageous. A broadly emerging type of programming methodology which promises to offer even more favorable efficiencies in program development and maintenance is object oriented programming software design. Object oriented programming software design is based on the concept of extracting particular characteristics from some item of interest along with a set of operations that may be performed on that information and grouping those pieces together to form an object. There are several benefits that may be realized by the implementation of a computer system in an object oriented programming environment. For example, compiler output including both generated program code and symbolic object references may be directly received, stored and integrated into an existing runtime system without further coordination with the already resident program and object references in the system. This capability is of significant value when large programs are created in pieces by large teams of programmers. Currently available object oriented programming languages include ADA 95, C, C++ and JAVA.TM. languages.
The JAVA programming language was created and propagated by Sun Micro Systems, Inc. to meet the need for an object oriented, platform independent and network enabled programming environment. The JAVA language has been quickly embraced by the computer software community and has been demonstrated to be efficient and robust for a wide variety of general purpose computing applications while generally providing improved development productivity. The successful performance of the JAVA programming language has resulted in a great interest in the use of the JAVA programming language for a wide variety of computing applications, including real time, embedded computing applications.
A program written in the JAVA language is compiled from the JAVA source code into as a series of platform independent commands called "bytecodes." Generally, a JAVA host computer system utilizes a JAVA run time environment to interpret and execute the bytecodes. The JAVA run time environment is called a "JAVA virtual machine" (JVM) and it can either interpret the bytecodes directly or use a "just-in-time" compiler to convert the bytecodes to platform dependent codes which run directly on the host platform. The JVM allows a flexible run-time environment.
However, in some aspects the JAVA language and the JVM are not well suited for real-time embedded processors. A conventional JVM is created with the expectation that it will be utilized on a hardware platform (general purpose computer system) with large random access memory (RAM) storage and high-speed performance. Due to this expectation, JAVA programs often include unused methods, fields and constants. Although the storage of unused methods, fields and constants is not problematic in general purpose computing systems where large amounts of memory are available, the storage of unused methods, fields and constants is a problem in embedded applications due to limited operation times and memory. Additionally, JAVA programs often rely on calls (e.g. invokes) to subroutines or methods. These calls to subroutines can require additional space and time when compared to an assembly language performance of the subroutine. Conventional JAVA compilers do not provide a mechanism for replacing slower JAVA subroutines with faster subroutine assembly code functions.
Further, the JAVA language has certain characteristics which make it difficult to use in embedded processing environments which use ROM storage for program code. In particular, JAVA programs utilize an object referencing mechanism, whereby symbolic references to objects are embedded in JAVA bytecode sequences. The symbolic references are typically employed to access a table of logical locations of the referenced objects that provide the information needed to address the objects. In a typical referencing operation, after the first access to an object, the logical location of the object is stored and the program code is modified so that subsequent accesses can bypass the symbolic reference resolution process and use the stored value. In embedded systems which store the program code in ROM, the program code cannot be modified to change the symbolic resolution process.
Further, the interpretation of the bytecodes by a processor running another process, such as occurs in the JVM, is inherently speed inefficient. In applications where higher performance or lower power consumption is required, this inefficiency may be intolerable.
Finally, the JVM definition for operation with the JAVA language requires the existence of an automatic storage management system called a "garbage collector" which automatically reclaims storage that is no longer in use. Most conventional garbage collectors are known to be a significant problem for embedded real time applications because the garbage collection process requires a significant period of time and must be properly completed before applications attempt to access objects in storage. Accordingly, the processor is essentially unavailable while the garbage collection process is active and reclaiming unused storage and other application programs must be halted until the garbage collection task is complete.
Thus, there is a need for a processor which can be used in real-time embedded applications which can efficiently run JAVA programs in order to reduce program development time and program maintenance costs.